﻿using Emc.InputAccel.CaptureClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using mapfre.odeon;
using Emc.InputAccel.UimScript;


namespace GENERALITAT_CATALUNYA
{
    public class calcular_puntuaciones : CustomCodeModule
    {
        public override void ExecuteTask(IClientTask task, IBatchContext batchContext)
        {

               /*========================================
                *CODE: Calcular_puntuaciones_alumno
                *Autor: Marc Bayón Benegas
                *Propiedad: SMTECNOLOGIA(c) 
                *Proyecto: GENERALITAT_Catalunya
                * .NET Framework V 3.5
                * 
                * Funcionalidades:
                * ===============
                * 
                * INPUT: Vector de Respuestas del alumno, ya sea por extracción manual o automática
                * OUTPUT: Vector de puntuaciones del alumno
                * 
                * Este código se ejecuta por cada examen.
                * 
                * 1) Leer CustomValue : respuesas_alumno
                * 2) Verificar respuesta con lista de respuesta de correctas (ver CustomValues respuestas_XXX, siendo XXX el examen en cuestion)
                * 3) Otorgar puntuación (escribir en Customvalues notas_alumno)
                * 
                */

            LogManager.log("=============================================================");
            LogManager.log("Incio Ejecución Módulo CALCULAR_Puntuaciones_Alumno");
            LogManager.log("Iniciando ejecución para lote: " + batchContext.BatchName + " con ID: " + batchContext.BatchId+ "Fecha/hora: "+DateTime.Now.ToString());
            IBatchNode nodo_recognition = batchContext.GetStepNode(task.BatchNode, "Extraction");
            IBatchNode nodo_custom = batchContext.GetStepNode(task.BatchNode, "CustomValues");
            String respuestas_correctas = String.Empty;
            String puntuacion = String.Empty;
            String extracción_manual = nodo_custom.NodeData.ValueSet.ReadString("Extraccion_Manual");
            String respuestas_alumno = String.Empty;
            String ausente = string.Empty;
            String valoracion_prueba = string.Empty;
            

            
            if (!extracción_manual.Equals("TRUE"))
            { 
                string uimdata = nodo_recognition.NodeData.ValueSet.ReadString("UimData");

                IUimDataContext data = nodo_recognition.NodeData.StringToUimData(uimdata);
                               
                LogManager.log("Leyendo UIMDATA");
                Dictionary<String,String> respuestas = new Dictionary<String,String>();
                
                string contador_pregunta = string.Empty;
                ausente = (String)nodo_recognition.NodeData.StringToUimData(uimdata).FindFieldDataContext("Ausente").Value;
                LogManager.log("Leyendo Campo: Ausente");
                LogManager.log("Valor: "+ausente);
                ausente = ausente.ToUpper();

                if (!ausente.Equals("X"))
                {
                    foreach (IUimFieldDataContext campo in data.GetFieldDataContextArray())
                    {
                        LogManager.log("Leyendo Campo: " + campo.Name);
                        if (campo.Name.Contains("Campo"))
                        {
                            string[] nombre_pregunta = campo.Name.Split('o'); //Campo1_a_1
                            string[] num_pregunta = nombre_pregunta[1].Split('_');//1_a_1

                            if (num_pregunta.Length > 2)
                            {
                                contador_pregunta = num_pregunta[0] + "." + num_pregunta[1];//1.1
                            }
                            else
                            {
                                contador_pregunta = num_pregunta[0];//1
                            }

                            if (campo.Name.Contains("_a"))
                            {

                                if (campo.ValueAsString.Equals("X") || campo.ValueAsString.Equals("x"))
                                {
                                    if (!respuestas.ContainsKey(contador_pregunta))
                                    {
                                        respuestas.Add(contador_pregunta, "a,");
                                    }
                                    else
                                    {
                                        respuestas[contador_pregunta] = "N,";
                                    }

                                    LogManager.log("Asigando valor a cadena: " + respuestas[contador_pregunta]);
                                }
                            }
                            if (campo.Name.Contains("_b"))
                            {
                                if (campo.ValueAsString.Equals("X") || campo.ValueAsString.Equals("x"))
                                {
                                    if (!respuestas.ContainsKey(contador_pregunta))
                                    {
                                        respuestas.Add(contador_pregunta, "b,");
                                    }
                                    else
                                    {
                                        respuestas[contador_pregunta] = "N,";
                                    }
                                    LogManager.log("Asigando valor a cadena: " + respuestas[contador_pregunta]);
                                }
                            }
                            if (campo.Name.Contains("_c"))
                            {
                                if (campo.ValueAsString.Equals("X") || campo.ValueAsString.Equals("x"))
                                {
                                    if (!respuestas.ContainsKey(contador_pregunta))
                                    {
                                        respuestas.Add(contador_pregunta, "c,");
                                    }
                                    else
                                    {
                                        respuestas[contador_pregunta] = "N,";
                                    }
                                    LogManager.log("Asigando valor a cadena: " + respuestas[contador_pregunta]);
                                }
                            }
                            if (campo.Name.Contains("_d"))
                            {
                                if (campo.ValueAsString.Equals("X") || campo.ValueAsString.Equals("x"))
                                {
                                    if (!respuestas.ContainsKey(contador_pregunta))
                                    {
                                        respuestas.Add(contador_pregunta, "d,");
                                    }
                                    else
                                    {
                                        respuestas[contador_pregunta] = "N,";
                                    }
                                    LogManager.log("Asigando valor a cadena: " + respuestas[contador_pregunta]);
                                }
                            }
                        }
                    }

                    //verificación de las repuestas
                    List<string> valores = respuestas.Values.ToList<string>();

                    string cad = String.Empty;
                    foreach (string s in valores)
                    {
                        cad = cad + s;
                    }

                    nodo_custom.NodeData.ValueSet.WriteString("Respuestas_alumno", cad);
                    respuestas_alumno = cad;

                    //Valoracion prueba
                    string muy_facil = (String)nodo_recognition.NodeData.StringToUimData(uimdata).FindFieldDataContext("Muy_facil").Value;
                    string facil = (String)nodo_recognition.NodeData.StringToUimData(uimdata).FindFieldDataContext("Facil").Value;
                    string dificil = (String)nodo_recognition.NodeData.StringToUimData(uimdata).FindFieldDataContext("Dificil").Value;
                    string muy_dificil = (String)nodo_recognition.NodeData.StringToUimData(uimdata).FindFieldDataContext("Muy_dificil").Value;

                    if (muy_facil.Equals("x") ||muy_facil.Equals("X"))
                    {
                        valoracion_prueba = "1";
                    }
                    else if (facil.Equals("x") ||facil.Equals("X"))
                    {
                        valoracion_prueba = "2";
                    }
                    else if (dificil.Equals("x") || dificil.Equals("X"))
                    {
                        valoracion_prueba = "3";
                    }
                    else if (muy_dificil.Equals("x") || muy_dificil.Equals("X"))
                    {
                        valoracion_prueba = "4";
                    }
                    else
                    {
                        valoracion_prueba = "0";
                    }
                }
                else
                {
                    LogManager.log("EL ALUMNO ESTÁ AUSENTE, no se porcesan los datos");
                    nodo_custom.NodeData.ValueSet.WriteString("Ausente", "S");
                    ausente = "S";
                    valoracion_prueba = "0";
                }

            }
            else
            {
                ausente = nodo_custom.NodeData.ValueSet.ReadString("Ausente");
                if (!ausente.Equals("S"))
                { 
                    respuestas_alumno = nodo_custom.NodeData.ValueSet.ReadString("Respuestas_alumno");
                    valoracion_prueba = nodo_custom.NodeData.ValueSet.ReadString("Valoracion_prueba");

                }
                else
                {
                    valoracion_prueba = "0";
                }
            }
            
            //CORECCION

            if(!ausente.Equals("S"))
            { 

                String tipo_examen = nodo_custom.NodeData.ValueSet.ReadString("Plantilla");

                LogManager.log("Plantilla DETECTADA: "+tipo_examen);

                if (tipo_examen.Equals("CAS"))
                {
                    respuestas_correctas = nodo_custom.NodeData.ValueSet.ReadString("Respuestas_CAS");
                }
                if (tipo_examen.Equals("EXT"))
                {
                    respuestas_correctas = nodo_custom.NodeData.ValueSet.ReadString("Respuestas_EXT");
                }
                if (tipo_examen.Equals("CAT"))
                {
                    respuestas_correctas = nodo_custom.NodeData.ValueSet.ReadString("Respuestas_CAT");
                }
                if (tipo_examen.Equals("MAT"))
                {
                    respuestas_correctas = nodo_custom.NodeData.ValueSet.ReadString("Respuestas_MAT");
                }

                String [] respuestas_correctas_divididas = respuestas_correctas.Split(',');
                String [] respuestas_alumno_divididas = respuestas_alumno.Split(',');

                LogManager.log("Comparando:\nRespuestas_ALUM: " + respuestas_alumno+ "\nRespuestas_OKIS: " + respuestas_correctas+"\n");

                for (int i = 0; i < respuestas_correctas_divididas.Length; i++ )
                {
                    LogManager.log("Comparando: ALUM: " + respuestas_alumno_divididas[i] + " OKIS: " + respuestas_correctas_divididas[i] + "\n");
                    if (respuestas_alumno_divididas[i].Equals(respuestas_correctas_divididas[i]))
                    {
                        puntuacion = puntuacion + "1,";
                    }
                    else
                    {
                        puntuacion = puntuacion + "0,";
                    }

                }

                puntuacion = puntuacion + valoracion_prueba;//finalmente va la valoración de la prueba para el WS

                nodo_custom.NodeData.ValueSet.WriteString("Notas", puntuacion);
                LogManager.log("Alumno Puntuado Correctamente:" + puntuacion);


            }
            else
            {

                puntuacion = "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0";
                nodo_custom.NodeData.ValueSet.WriteString("Notas", puntuacion);
                nodo_custom.NodeData.ValueSet.WriteString("Valoracion_prueba", valoracion_prueba);
                LogManager.log("El ALUMNO está AUSENTE, NO PUNTUADO");

            }

            LogManager.log("Fin EJECUCIÓN: " + DateTime.Now.ToString());
            LogManager.log("=============================================================");
            task.CompleteTask();
        }

        public override void StartModule(ICodeModuleStartInfo startInfo)
        {
            LogManager.moduleInfo = startInfo;
        }
    }
}
